#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""检测管理器模块
反侦查技术的主控制器，整合环境检测、代码保护、反调试和内存保护功能"""

import os
import sys
import threading
import time
import random
import platform
from utils import Logger
from utils.anti_detection.environment_detector import EnvironmentDetector
from utils.anti_detection.code_protector import CodeProtector
from utils.anti_detection.anti_debugger import AntiDebugger
from utils.anti_detection.memory_protector import MemoryProtector
from utils.anti_detection.code_encryptor import CodeEncryptor
from utils.anti_detection.code_obfuscator import CodeObfuscator

class DetectionManager:
    """检测管理器
    反侦查技术的主控制器，负责协调环境检测和代码保护"""
    
    def __init__(self):
        """初始化检测管理器"""
        # 基础反侦查组件
        self.environment_detector = EnvironmentDetector()
        self.code_protector = CodeProtector()
        
        # 高级反侦查组件
        self.anti_debugger = AntiDebugger()
        self.memory_protector = MemoryProtector()
        self.code_encryptor = CodeEncryptor()
        self.code_obfuscator = CodeObfuscator()
        
        # 配置标志
        self.is_protection_enabled = True
        self.is_monitoring_enabled = True
        self.is_advanced_protection_enabled = True
        
        # 线程控制
        self._monitoring_thread = None
        self._stop_event = threading.Event()
        self._detection_lock = threading.Lock()
        
        Logger.log_info("检测管理器初始化完成")
    
    def start_protection(self):
        """启动反侦查保护系统
        
        Returns:
            bool: 是否启动成功
        """
        Logger.log_info("启动反侦查保护系统...")
        
        try:
            # 执行初始环境检测
            if self.is_protection_enabled:
                is_debug_env = self.environment_detector.detect_debug_environment()
                
                if is_debug_env:
                    Logger.log_warning("检测到潜在的调试环境")
                    # 执行环境清理
                    self.environment_detector.perform_environment_sanitization()
                    
                    # 根据检测结果执行相应的保护措施
                    self._execute_protection_measures(is_debug_env)
            
            # 启动持续监控
            if self.is_monitoring_enabled:
                self._start_monitoring()
            
            # 启动高级保护组件
            if self.is_advanced_protection_enabled:
                # 启动反调试监控
                self.anti_debugger.start_monitoring()
                
                # 启动内存保护
                self.memory_protector.start_protection()
            
            Logger.log_info("反侦查保护系统启动成功")
            return True
        except Exception as e:
            Logger.log_error(f"启动反侦查保护系统失败: {str(e)}")
            return False
    
    def _start_monitoring(self):
        """启动持续监控"""
        Logger.log_info("启动持续监控...")
        
        def monitoring_task():
            while not self._stop_event.is_set():
                try:
                    # 随机化检测间隔，避免被预测
                    sleep_time = random.randint(30, 120)  # 30到120秒之间的随机间隔
                    time.sleep(sleep_time)
                    
                    # 执行环境检测
                    with self._detection_lock:
                        is_debug_env = self.environment_detector.detect_debug_environment()
                        
                        if is_debug_env:
                            Logger.log_warning("持续监控检测到潜在的调试环境")
                            self._execute_protection_measures(is_debug_env)
                except Exception as e:
                    Logger.log_error(f"持续监控任务异常: {str(e)}")
                    # 发生异常时，短暂暂停后继续
                    time.sleep(5)
        
        # 创建并启动后台线程
        self._monitoring_thread = threading.Thread(target=monitoring_task, daemon=True)
        self._monitoring_thread.start()
        
        return self._monitoring_thread
    
    def _execute_protection_measures(self, is_debug_env):
        """执行保护措施
        
        Args:
            is_debug_env: 是否检测到调试环境
        """
        if not is_debug_env:
            return
        
        Logger.log_info("执行保护措施...")
        
        # 根据检测到的问题严重程度，执行不同的保护措施
        detected_issues = self.environment_detector.get_detected_issues()
        issue_count = len(detected_issues)
        
        # 问题级别
        if issue_count >= 3:  # 严重级别
            Logger.log_warning("检测到严重的安全威胁，执行高级保护措施")
            self._execute_advanced_protection()
        elif issue_count >= 1:  # 中等级别
            Logger.log_warning("检测到中等安全威胁，执行中级保护措施")
            self._execute_medium_protection()
        
        # 记录安全事件
        self._log_security_event("debug_environment_detected", {
            "issues": detected_issues,
            "issue_count": issue_count,
            "timestamp": time.time(),
            "platform": platform.system(),
            "python_version": platform.python_version()
        })
    
    def _execute_advanced_protection(self):
        """执行高级保护措施"""
        Logger.log_warning("执行高级保护措施")
        
        if not self.is_advanced_protection_enabled:
            Logger.log_info("高级保护功能已禁用")
            return
        
        try:
            # 1. 保护内存中的关键数据
            Logger.log_warning("高级保护措施：保护内存中的关键数据")
            
            # 2. 检查是否有调试器附加
            if self.anti_debugger._detect_debugger():
                Logger.log_warning("高级保护措施：检测到调试器，执行紧急应对策略")
                
                # 3. 混淆关键模块代码
                Logger.log_warning("高级保护措施：混淆关键模块代码")
                for module_name in ["utils.security_utils", "utils.auto_update.update_manager"]:
                    if module_name in sys.modules:
                        module = sys.modules[module_name]
                        # 尝试使用代码混淆器混淆模块
                        try:
                            self.code_obfuscator.obfuscate_module(module)
                        except Exception as e:
                            Logger.log_error(f"混淆模块 {module_name} 失败: {str(e)}")
            
            # 4. 清除敏感数据
            Logger.log_warning("高级保护措施：清除敏感数据")
            # 这里可以添加清除敏感数据的代码
        except Exception as e:
            Logger.log_error(f"执行高级保护措施时发生错误: {str(e)}")
    
    def _execute_medium_protection(self):
        """执行中级保护措施"""
        Logger.log_warning("执行中级保护措施")
        
        # 1. 清理环境
        self.environment_detector.perform_environment_sanitization()
        
        # 2. 对关键模块进行重新保护
        self._reprotect_critical_modules()
    
    def _reprotect_critical_modules(self):
        """重新保护关键模块"""
        Logger.log_info("重新保护关键模块...")
        
        # 定义关键模块
        critical_modules = [
            "utils.security_utils",
            "utils.auto_update.update_manager"
        ]
        
        # 对每个关键模块进行保护
        for module_name in critical_modules:
            try:
                # 检查模块是否已导入
                if module_name in sys.modules:
                    module = sys.modules[module_name]
                    
                    # 对模块进行保护
                    self.code_protector._protect_module_code(module)
                    Logger.log_info(f"已重新保护模块: {module_name}")
            except Exception as e:
                Logger.log_error(f"重新保护模块 {module_name} 时发生错误: {str(e)}")
    
    def _log_security_event(self, event_type, event_data):
        """记录安全事件
        
        Args:
            event_type: 事件类型
            event_data: 事件数据
        """
        # 在实际应用中，这里应该有更复杂的日志记录逻辑
        # 例如，将安全事件存储到安全日志文件中
        Logger.log_info(f"安全事件记录: {event_type}, 数据: {event_data}")
    
    def enable_protection(self):
        """启用反侦查保护
        
        Returns:
            bool: 是否启用成功
        """
        self.is_protection_enabled = True
        Logger.log_info("已启用反侦查保护")
        return True
    
    def disable_protection(self):
        """禁用反侦查保护
        
        Returns:
            bool: 是否禁用成功
        """
        self.is_protection_enabled = False
        Logger.log_info("已禁用反侦查保护")
        return True
    
    def enable_monitoring(self):
        """启用持续监控
        
        Returns:
            bool: 是否启用成功
        """
        if not self.is_monitoring_enabled:
            self.is_monitoring_enabled = True
            self._start_monitoring()
            Logger.log_info("已启用持续监控")
        return True
    
    def disable_monitoring(self):
        """禁用持续监控
        
        Returns:
            bool: 是否禁用成功
        """
        if self.is_monitoring_enabled:
            self.is_monitoring_enabled = False
            self._stop_event.set()
            if self._monitoring_thread and self._monitoring_thread.is_alive():
                self._monitoring_thread.join(timeout=2.0)
            Logger.log_info("已禁用持续监控")
        return True
    
    def protect_sensitive_code(self, code_string):
        """保护敏感代码
        
        Args:
            code_string: 敏感代码字符串
            
        Returns:
            function: 受保护的代码执行器
        """
        if not self.is_protection_enabled:
            Logger.log_warning("反侦查保护已禁用，无法保护敏感代码")
            
            # 如果保护已禁用，返回一个简单的执行器
            def simple_executor(*args, **kwargs):
                try:
                    exec(code_string)
                except Exception:
                    pass
                return None
            
            return simple_executor
        
        Logger.log_info("保护敏感代码...")
        return self.code_protector.create_protected_executor(code_string)
    
    def check_environment(self):
        """手动检查环境
        
        Returns:
            dict: 包含检测结果的字典
        """
        Logger.log_info("手动检查环境...")
        
        with self._detection_lock:
            is_debug_env = self.environment_detector.detect_debug_environment()
            detected_issues = self.environment_detector.get_detected_issues()
            
            return {
                "is_debug_env": is_debug_env,
                "issues": detected_issues,
                "issue_count": len(detected_issues)
            }
    
    def cleanup(self):
        """清理反侦查保护系统资源"""
        Logger.log_info("清理反侦查保护系统资源...")
        
        try:
            # 停止监控线程
            self.disable_monitoring()
            
            # 清理高级反侦查组件资源
            if self.is_advanced_protection_enabled:
                # 停止反调试监控
                self.anti_debugger.stop_monitoring()
                
                # 停止内存保护
                self.memory_protector.stop_protection()
                
                # 清理代码加密器资源
                self.code_encryptor.cleanup()
            
            Logger.log_info("反侦查保护系统资源清理完成")
        except Exception as e:
            Logger.log_error(f"清理反侦查保护系统资源时发生错误: {str(e)}")

# 示例用法
if __name__ == "__main__":
    detection_manager = DetectionManager()
    
    # 启动反侦查保护系统
    detection_manager.start_protection()
    
    try:
        print("反侦查保护系统已启动，按Ctrl+C停止...")
        
        # 手动检查环境
        print("\n手动检查环境:")
        result = detection_manager.check_environment()
        print(f"是否为调试环境: {result['is_debug_env']}")
        print(f"检测到的问题数量: {result['issue_count']}")
        if result['issues']:
            print("检测到的问题:")
            for issue in result['issues']:
                print(f"- {issue}")
        
        # 保护一段敏感代码
        sensitive_code = """
# 这是一段敏感代码
secret_data = 'This is sensitive information'
print(f'Sensitive data processed: {secret_data}')
result = 'Protected operation completed'
"""
        
        print("\n保护敏感代码...")
        protected_executor = detection_manager.protect_sensitive_code(sensitive_code)
        
        # 执行受保护的代码
        print("执行受保护的代码...")
        result = protected_executor()
        print(f"代码执行结果: {result}")
        
        # 保持运行一段时间
        time.sleep(60)
    except KeyboardInterrupt:
        print("用户中断操作")
    finally:
        # 清理资源
        detection_manager.cleanup()